package appModels

import (
	"errors"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/util/gvalid"
	"xorm.io/builder"
	"xorm.io/xorm"
)

type Dictionary struct {
	Models   `xorm:"extends"`
	Title    string           `json:"title" xorm:"varchar(255)"`                   //字典名称
	OnlyKey  string           `json:"only_key" xorm:"varchar(255)"`                //字典唯一key
	Type     int              `json:"type" xorm:"int(1) notnull default(1)"`       //1字典 2系统设置
	Multiple int              `json:"multiple" xorm:"int(1) notnull default(1)"`   //1单个数据 2多个数据【数组】
	IntType  int              `json:"int_type" xorm:"int(1) notnull default(1)"`   //1字符串  2整数  3小数
	Value    DictionaryVal    `json:"value" xorm:"text json"`                      //单个值
	Values   []DictionaryVal  `json:"values" xorm:"text json"`                     //多个值
	Enable   int              `json:"enable" xorm:"tinyint(1) notnull default(1)"` //是否启用 ，1启用 2禁用
	Sort     int              `json:"sort" xorm:"int(11) notnull default(1)"`      //排序
	Desc     string           `json:"desc" xorm:"varchar(255)"`                    //备注
	MCreated `xorm:"extends"` //继承创建时间字段
}

type DictionaryVal struct {
	Label           string  `json:"label"`            // 数据标签
	StrValue        string  `json:"str_value"`        // 字符数据
	IntValue        int64   `json:"int_value"`        // 整数数据
	FloatValue      float64 `json:"float_value"`      // 小数数据
	TxtColor        string  `json:"txt_color"`        // 数据表现文本颜色
	BackgroundColor string  `json:"background_color"` // 数据表现背景颜色
}

func (this *Dictionary) getTypeName() string {
	if this.Type == 1 {
		return "字典"
	} else if this.Type == 2 {
		return "系统设置"
	}
	return ""
}

//添加数据校验
func (this *Dictionary) AddValid() error {
	rules := []string{
		"Id@required#ID不能为空",
		"Title@required#字典名称不能为空",
		"OnlyKey@required#唯一key不能为空",
	}
	err := gvalid.CheckStruct(this, rules, nil)
	if err == nil {
		return nil
	} else {
		return errors.New(err.FirstString())
	}
}

//修改数据校验
func (this *Dictionary) EditValid() error {
	return this.AddValid()
}

//获取模型
func (this *Dictionary) Model() interface{} {
	return new(Dictionary)
}

//获取模型切片
func (this *Dictionary) Slice() interface{} {
	return new([]Dictionary)
}

//初始化数据
func (this *Dictionary) Init(db *xorm.Session, guid string, loginUser *UserInfo) error {
	this.Id = guid
	this.Bid = loginUser.Account.Bid
	return nil
}

//添加之前调用，判断是否可添加，设置添加条件等
func (this *Dictionary) AddWhere(db *xorm.Session, loginUser *UserInfo) error {
	db.Where(builder.Eq{
		"only_key": this.OnlyKey,
		"type":     this.Type,
	})
	has, err := db.Exist(new(Dictionary))
	if err != nil {
		g.Log().Errorf("添加失败，查询%vKEY是否存在，错误：%v", this.getTypeName(), err)
		return errors.New("添加失败")
	}
	if has {
		return errors.New("添加失败," + this.getTypeName() + "KEY已经存在")
	}
	return nil
}

//删除之前调用，判断是否可删除，设置删除条件等
func (this *Dictionary) DeleteWhere(db *xorm.Session, loginUser *UserInfo, ids ...string) error {
	db.Where(builder.In("id", ids).And(builder.Eq{"type": this.Type}))
	return nil
}

//修改之前调用，判断是否可修改，设置修改条件
func (this *Dictionary) EditWhere(db *xorm.Session, loginUser *UserInfo) error {
	db.Where(builder.Eq{"only_key": this.OnlyKey, "type": this.Type}.And(builder.Neq{"id": this.Id}))
	has, err := db.Exist(new(Dictionary))
	if err != nil {
		g.Log().Errorf("修改失败，查询%vKEY是否存在，错误：%v", this.getTypeName(), err)
		return errors.New("修改失败")
	}
	if has {
		return errors.New("修改失败," + this.getTypeName() + "KEY已经存在")
	}
	db.Where(builder.Eq{"id": this.Id, "type": this.Type})
	db.MustCols("desc")
	return nil
}

//查询一条数据条件
func (this *Dictionary) GetWhere(db *xorm.Session, loginUser *UserInfo, typeStr string) error {
	db.Where(builder.Eq{"only_key": typeStr, "type": this.Type, "enable": 1})
	return nil
}

//查询列表条件、查询分页数据条数条件
func (this *Dictionary) ListWhere(db *xorm.Session, loginUser *UserInfo) error {
	db.Asc("sort").Desc("created")
	db.Where(builder.Eq{"type": this.Type})
	if this.Title != "" {
		db.Where(builder.Like{"title", this.Title})
	}
	if this.OnlyKey != "" {
		db.Where(builder.Like{"only_key", this.OnlyKey})
	}
	/*if this.Bid != "" {
		db.Where(builder.Eq{"bid": this.Bid})
	}*/
	return nil
}

//查询分页时条件
func (this *Dictionary) PaginateWhere(db *xorm.Session, loginUser *UserInfo) error {
	db.Asc("sort")
	db.Where(builder.Eq{"type": this.Type})
	if this.Title != "" {
		db.Where(builder.Like{"title", this.Title})
	}
	if this.OnlyKey != "" {
		db.Where(builder.Like{"only_key", this.OnlyKey})
	}
	return nil
}
